package util;

import java.util.Scanner;
import model.Order.OrderStatus;

/**
 * 输入校验工具类
 * 提供各种类型的输入校验方法，防止用户输入错误导致程序异常
 * @author 系统
 * @version 1.0
 */
public class InputValidator { // 输入校验工具类 完成人：姜凯严 7/3
    
    /**
     * 获取有效的正整数输入（不可为空）
     * @param scanner 扫描器
     * @param prompt 提示信息
     * @param fieldName 字段名称（用于错误提示）
     * @return 有效的正整数
     */
    public static int getValidPositiveInt(Scanner scanner, String prompt, String fieldName) {
        while (true) {
            System.out.print(prompt);
            String input = scanner.nextLine().trim();
            if (input.isEmpty()) {
                System.out.println(fieldName + "不能为空！请重新输入。");
                continue;
            }
            try {
                int value = Integer.parseInt(input);
                if (value <= 0) {
                    System.out.println(fieldName + "必须为正整数！请重新输入。");
                    continue;
                }
                return value;
            } catch (NumberFormatException e) {
                System.out.println(fieldName + "格式错误！请输入有效的整数。");
            }
        }
    }
    
    /**
     * 获取有效的非负整数输入（不可为空）
     * @param scanner 扫描器
     * @param prompt 提示信息
     * @param fieldName 字段名称（用于错误提示）
     * @return 有效的非负整数
     */
    public static int getValidNonNegativeInt(Scanner scanner, String prompt, String fieldName) {
        while (true) {
            System.out.print(prompt);
            String input = scanner.nextLine().trim();
            if (input.isEmpty()) {
                System.out.println(fieldName + "不能为空！请重新输入。");
                continue;
            }
            try {
                int value = Integer.parseInt(input);
                if (value < 0) {
                    System.out.println(fieldName + "不能为负数！请重新输入。");
                    continue;
                }
                return value;
            } catch (NumberFormatException e) {
                System.out.println(fieldName + "格式错误！请输入有效的整数。");
            }
        }
    }
    
    /**
     * 获取有效的正整数输入（可留空）
     * @param scanner 扫描器
     * @param prompt 提示信息
     * @param fieldName 字段名称（用于错误提示）
     * @param currentValue 当前值
     * @return 有效的正整数，如果输入为空则返回原值
     */
    public static int getValidPositiveIntOptional(Scanner scanner, String prompt, String fieldName, int currentValue) {
        System.out.print(prompt);
        String input = scanner.nextLine().trim();
        if (input.isEmpty()) {
            return currentValue; // 输入为空，返回原值
        }
        try {
            int value = Integer.parseInt(input);
            if (value <= 0) {
                System.out.println(fieldName + "必须为正整数！");
                return -1; // 返回错误标识
            }
            return value;
        } catch (NumberFormatException e) {
            System.out.println(fieldName + "格式错误！请输入有效的整数。");
            return -1; // 返回错误标识
        }
    }
    
    /**
     * 获取有效的非负整数输入（可留空）
     * @param scanner 扫描器
     * @param prompt 提示信息
     * @param fieldName 字段名称（用于错误提示）
     * @param currentValue 当前值
     * @return 有效的非负整数，如果输入为空则返回原值
     */
    public static int getValidNonNegativeIntOptional(Scanner scanner, String prompt, String fieldName, int currentValue) {
        System.out.print(prompt);
        String input = scanner.nextLine().trim();
        if (input.isEmpty()) {
            return currentValue; // 输入为空，返回原值
        }
        try {
            int value = Integer.parseInt(input);
            if (value < 0) {
                System.out.println(fieldName + "不能为负数！");
                return -1; // 返回错误标识
            }
            return value;
        } catch (NumberFormatException e) {
            System.out.println(fieldName + "格式错误！请输入有效的整数。");
            return -1; // 返回错误标识
        }
    }
    
    /**
     * 获取有效的正数输入（不可为空）
     * @param scanner 扫描器
     * @param prompt 提示信息
     * @param fieldName 字段名称（用于错误提示）
     * @return 有效的正数
     */
    public static double getValidPositiveDouble(Scanner scanner, String prompt, String fieldName) {
        while (true) {
            System.out.print(prompt);
            String input = scanner.nextLine().trim();
            if (input.isEmpty()) {
                System.out.println(fieldName + "不能为空！请重新输入。");
                continue;
            }
            try {
                double value = Double.parseDouble(input);
                if (value <= 0) {
                    System.out.println(fieldName + "必须大于0！请重新输入。");
                    continue;
                }
                return value;
            } catch (NumberFormatException e) {
                System.out.println(fieldName + "格式错误！请输入有效的数字。");
            }
        }
    }
    
    /**
     * 获取有效的非负数输入（可留空）
     * @param scanner 扫描器
     * @param prompt 提示信息
     * @param fieldName 字段名称（用于错误提示）
     * @param currentValue 当前值
     * @return 有效的非负数，如果输入为空则返回原值
     */
    public static double getValidNonNegativeDoubleOptional(Scanner scanner, String prompt, String fieldName, double currentValue) {
        System.out.print(prompt);
        String input = scanner.nextLine().trim();
        if (input.isEmpty()) {
            return currentValue; // 输入为空，返回原值
        }
        try {
            double value = Double.parseDouble(input);
            if (value < 0) {
                System.out.println(fieldName + "不能为负数！");
                return -1; // 返回错误标识
            }
            return value;
        } catch (NumberFormatException e) {
            System.out.println(fieldName + "格式错误！请输入有效的数字。");
            return -1; // 返回错误标识
        }
    }
    
    /**
     * 获取有效的布尔值输入（不可为空）
     * @param scanner 扫描器
     * @param prompt 提示信息
     * @param fieldName 字段名称（用于错误提示）
     * @return true或false
     */
    public static boolean getValidBoolean(Scanner scanner, String prompt, String fieldName) {
        while (true) {
            System.out.print(prompt);
            String input = scanner.nextLine().trim();
            if (input.isEmpty()) {
                System.out.println(fieldName + "不能为空！请重新输入。");
                continue;
            }
            try {
                int value = Integer.parseInt(input);
                if (value != 0 && value != 1) {
                    System.out.println("请输入0或1！0表示否，1表示是。");
                    continue;
                }
                return value == 1;
            } catch (NumberFormatException e) {
                System.out.println("格式错误！请输入0或1。");
            }
        }
    }
    
    /**
     * 获取有效的布尔值输入（可留空）
     * @param scanner 扫描器
     * @param prompt 提示信息
     * @param fieldName 字段名称（用于错误提示）
     * @param currentValue 当前值
     * @return 有效的布尔值，如果输入为空则返回原值，出错返回null
     */
    public static Boolean getValidBooleanOptional(Scanner scanner, String prompt, String fieldName, boolean currentValue) {
        System.out.print(prompt);
        String input = scanner.nextLine().trim();
        if (input.isEmpty()) {
            return currentValue; // 输入为空，返回原值
        }
        try {
            int value = Integer.parseInt(input);
            if (value != 0 && value != 1) {
                System.out.println("请输入0或1！0表示否，1表示是。");
                return null; // 返回错误标识
            }
            return value == 1;
        } catch (NumberFormatException e) {
            System.out.println("格式错误！请输入0或1。");
            return null; // 返回错误标识
        }
    }
    
    /**
     * 获取有效的订单状态输入（不可为空）
     * @param scanner 扫描器
     * @param prompt 提示信息
     * @return 有效的订单状态
     */
    public static OrderStatus getValidOrderStatus(Scanner scanner, String prompt) {
        while (true) {
            System.out.print(prompt);
            String input = scanner.nextLine().trim();
            if (input.isEmpty()) {
                System.out.println("订单状态不能为空！请重新输入。");
                continue;
            }
            try {
                return OrderStatus.valueOf(input);
            } catch (IllegalArgumentException e) {
                System.out.println("订单状态无效！请输入：未付款、已付款、待收货、已完成 中的一个。");
            }
        }
    }
    
    /**
     * 获取有效的订单状态输入（可留空）
     * @param scanner 扫描器
     * @param prompt 提示信息
     * @param currentStatus 当前状态
     * @return 有效的订单状态，如果输入为空则返回原值，出错返回null
     */
    public static OrderStatus getValidOrderStatusOptional(Scanner scanner, String prompt, OrderStatus currentStatus) {
        System.out.print(prompt);
        String input = scanner.nextLine().trim();
        if (input.isEmpty()) {
            return currentStatus; // 输入为空，返回原值
        }
        try {
            return OrderStatus.valueOf(input);
        } catch (IllegalArgumentException e) {
            System.out.println("订单状态无效！请输入：未付款、已付款、待收货、已完成 中的一个。");
            return null; // 返回错误标识
        }
    }
    
    /**
     * 获取有效的非空字符串输入
     * @param scanner 扫描器
     * @param prompt 提示信息
     * @param fieldName 字段名称（用于错误提示）
     * @return 有效的非空字符串
     */
    public static String getValidNonEmptyString(Scanner scanner, String prompt, String fieldName) {
        while (true) {
            System.out.print(prompt);
            String input = scanner.nextLine().trim();
            if (input.isEmpty()) {
                System.out.println(fieldName + "不能为空！请重新输入。");
                continue;
            }
            return input;
        }
    }
    
    /**
     * 获取有效的价格范围输入（可留空）
     * @param scanner 扫描器
     * @param minPrompt 最小值提示
     * @param maxPrompt 最大值提示
     * @return 包含min和max的Double数组，[0]为min，[1]为max，出错返回null
     */
    public static Double[] getValidPriceRange(Scanner scanner, String minPrompt, String maxPrompt) {
        System.out.print(minPrompt);
        String minStr = scanner.nextLine().trim();
        System.out.print(maxPrompt);
        String maxStr = scanner.nextLine().trim();
        
        Double min = null, max = null;
        
        // 价格下限类型校验
        if (!minStr.isEmpty()) {
            try {
                min = Double.parseDouble(minStr);
                if (min < 0) {
                    System.out.println("价格下限不能为负数！");
                    return null;
                }
            } catch (NumberFormatException e) {
                System.out.println("价格下限格式错误！请输入有效的数字。");
                return null;
            }
        }
        
        // 价格上限类型校验
        if (!maxStr.isEmpty()) {
            try {
                max = Double.parseDouble(maxStr);
                if (max < 0) {
                    System.out.println("价格上限不能为负数！");
                    return null;
                }
            } catch (NumberFormatException e) {
                System.out.println("价格上限格式错误！请输入有效的数字。");
                return null;
            }
        }
        
        if (min == null) min = 0.0;
        if (min != null && max != null && min > max) {
            System.out.println("价格下限不能大于上限！");
            return null;
        }
        
        return new Double[]{min, max};
    }
}
